home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / arch / m68knommu / include / asm / dma.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  16.6 KB  |  495 lines
  1. #ifndef _M68K_DMA_H
  2. #define _M68K_DMA_H 1
  3.  
  4. //#define    DMA_DEBUG    1
  5.  
  6.  
  7. #ifdef CONFIG_COLDFIRE
  8. /*
  9.  * ColdFire DMA Model:
  10.  *   ColdFire DMA supports two forms of DMA: Single and Dual address. Single
  11.  * address mode emits a source address, and expects that the device will either
  12.  * pick up the data (DMA READ) or source data (DMA WRITE). This implies that
  13.  * the device will place data on the correct byte(s) of the data bus, as the
  14.  * memory transactions are always 32 bits. This implies that only 32 bit
  15.  * devices will find single mode transfers useful. Dual address DMA mode
  16.  * performs two cycles: source read and destination write. ColdFire will
  17.  * align the data so that the device will always get the correct bytes, thus
  18.  * is useful for 8 and 16 bit devices. This is the mode that is supported
  19.  * below.
  20.  *
  21.  * AUG/22/2000 : added support for 32-bit Dual-Address-Mode (K) 2000 
  22.  *               Oliver Kamphenkel (O.Kamphenkel@tu-bs.de)
  23.  *
  24.  * AUG/25/2000 : addad support for 8, 16 and 32-bit Single-Address-Mode (K)2000
  25.  *               Oliver Kamphenkel (O.Kamphenkel@tu-bs.de)
  26.  *
  27.  * APR/18/2002 : added proper support for MCF5272 DMA controller.
  28.  *               Arthur Shipkowski (art@videon-central.com)
  29.  */
  30.  
  31. #include <asm/coldfire.h>
  32. #include <asm/mcfsim.h>
  33. #include <asm/mcfdma.h>
  34.  
  35. /*
  36.  * Set number of channels of DMA on ColdFire for different implementations.
  37.  */
  38. #if defined(CONFIG_M5249) || defined(CONFIG_M5307) || defined(CONFIG_M5407) || \
  39.     defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x)
  40. #define MAX_M68K_DMA_CHANNELS 4
  41. #elif defined(CONFIG_M5272)
  42. #define MAX_M68K_DMA_CHANNELS 1
  43. #elif defined(CONFIG_M532x)
  44. #define MAX_M68K_DMA_CHANNELS 0
  45. #else
  46. #define MAX_M68K_DMA_CHANNELS 2
  47. #endif
  48.  
  49. extern unsigned int dma_base_addr[MAX_M68K_DMA_CHANNELS];
  50. extern unsigned int dma_device_address[MAX_M68K_DMA_CHANNELS];
  51.  
  52. #if !defined(CONFIG_M5272)
  53. #define DMA_MODE_WRITE_BIT  0x01  /* Memory/IO to IO/Memory select */
  54. #define DMA_MODE_WORD_BIT   0x02  /* 8 or 16 bit transfers */
  55. #define DMA_MODE_LONG_BIT   0x04  /* or 32 bit transfers */
  56. #define DMA_MODE_SINGLE_BIT 0x08  /* single-address-mode */
  57.  
  58. /* I/O to memory, 8 bits, mode */
  59. #define DMA_MODE_READ                0
  60. /* memory to I/O, 8 bits, mode */
  61. #define DMA_MODE_WRITE                1
  62. /* I/O to memory, 16 bits, mode */
  63. #define DMA_MODE_READ_WORD          2
  64. /* memory to I/O, 16 bits, mode */
  65. #define DMA_MODE_WRITE_WORD         3
  66. /* I/O to memory, 32 bits, mode */
  67. #define DMA_MODE_READ_LONG          4
  68. /* memory to I/O, 32 bits, mode */
  69. #define DMA_MODE_WRITE_LONG         5
  70. /* I/O to memory, 8 bits, single-address-mode */     
  71. #define DMA_MODE_READ_SINGLE        8
  72. /* memory to I/O, 8 bits, single-address-mode */
  73. #define DMA_MODE_WRITE_SINGLE       9
  74. /* I/O to memory, 16 bits, single-address-mode */
  75. #define DMA_MODE_READ_WORD_SINGLE  10
  76. /* memory to I/O, 16 bits, single-address-mode */
  77. #define DMA_MODE_WRITE_WORD_SINGLE 11
  78. /* I/O to memory, 32 bits, single-address-mode */
  79. #define DMA_MODE_READ_LONG_SINGLE  12
  80. /* memory to I/O, 32 bits, single-address-mode */
  81. #define DMA_MODE_WRITE_LONG_SINGLE 13
  82.  
  83. #else /* CONFIG_M5272 is defined */
  84.  
  85. /* Source static-address mode */
  86. #define DMA_MODE_SRC_SA_BIT 0x01  
  87. /* Two bits to select between all four modes */
  88. #define DMA_MODE_SSIZE_MASK 0x06 
  89. /* Offset to shift bits in */
  90. #define DMA_MODE_SSIZE_OFF  0x01  
  91. /* Destination static-address mode */
  92. #define DMA_MODE_DES_SA_BIT 0x10  
  93. /* Two bits to select between all four modes */
  94. #define DMA_MODE_DSIZE_MASK 0x60  
  95. /* Offset to shift bits in */
  96. #define DMA_MODE_DSIZE_OFF  0x05
  97. /* Size modifiers */
  98. #define DMA_MODE_SIZE_LONG  0x00
  99. #define DMA_MODE_SIZE_BYTE  0x01
  100. #define DMA_MODE_SIZE_WORD  0x02
  101. #define DMA_MODE_SIZE_LINE  0x03
  102.  
  103. /* 
  104.  * Aliases to help speed quick ports; these may be suboptimal, however. They
  105.  * do not include the SINGLE mode modifiers since the MCF5272 does not have a
  106.  * mode where the device is in control of its addressing.
  107.  */
  108.  
  109. /* I/O to memory, 8 bits, mode */
  110. #define DMA_MODE_READ                  ((DMA_MODE_SIZE_BYTE << DMA_MODE_DSIZE_OFF) | (DMA_MODE_SIZE_BYTE << DMA_MODE_SSIZE_OFF) | DMA_SRC_SA_BIT)
  111. /* memory to I/O, 8 bits, mode */
  112. #define DMA_MODE_WRITE                ((DMA_MODE_SIZE_BYTE << DMA_MODE_DSIZE_OFF) | (DMA_MODE_SIZE_BYTE << DMA_MODE_SSIZE_OFF) | DMA_DES_SA_BIT)
  113. /* I/O to memory, 16 bits, mode */
  114. #define DMA_MODE_READ_WORD            ((DMA_MODE_SIZE_WORD << DMA_MODE_DSIZE_OFF) | (DMA_MODE_SIZE_WORD << DMA_MODE_SSIZE_OFF) | DMA_SRC_SA_BIT)
  115. /* memory to I/O, 16 bits, mode */
  116. #define DMA_MODE_WRITE_WORD         ((DMA_MODE_SIZE_WORD << DMA_MODE_DSIZE_OFF) | (DMA_MODE_SIZE_WORD << DMA_MODE_SSIZE_OFF) | DMA_DES_SA_BIT)
  117. /* I/O to memory, 32 bits, mode */
  118. #define DMA_MODE_READ_LONG            ((DMA_MODE_SIZE_LONG << DMA_MODE_DSIZE_OFF) | (DMA_MODE_SIZE_LONG << DMA_MODE_SSIZE_OFF) | DMA_SRC_SA_BIT)
  119. /* memory to I/O, 32 bits, mode */
  120. #define DMA_MODE_WRITE_LONG         ((DMA_MODE_SIZE_LONG << DMA_MODE_DSIZE_OFF) | (DMA_MODE_SIZE_LONG << DMA_MODE_SSIZE_OFF) | DMA_DES_SA_BIT)
  121.  
  122. #endif /* !defined(CONFIG_M5272) */
  123.  
  124. #if !defined(CONFIG_M5272)
  125. /* enable/disable a specific DMA channel */
  126. static __inline__ void enable_dma(unsigned int dmanr)
  127. {
  128.   volatile unsigned short *dmawp;
  129.  
  130. #ifdef DMA_DEBUG
  131.   printk("enable_dma(dmanr=%d)\n", dmanr);
  132. #endif
  133.  
  134.   dmawp = (unsigned short *) dma_base_addr[dmanr];
  135.   dmawp[MCFDMA_DCR] |= MCFDMA_DCR_EEXT;
  136. }
  137.  
  138. static __inline__ void disable_dma(unsigned int dmanr)
  139. {
  140.   volatile unsigned short *dmawp;
  141.   volatile unsigned char  *dmapb;
  142.  
  143. #ifdef DMA_DEBUG
  144.   printk("disable_dma(dmanr=%d)\n", dmanr);
  145. #endif
  146.  
  147.   dmawp = (unsigned short *) dma_base_addr[dmanr];
  148.   dmapb = (unsigned char *) dma_base_addr[dmanr];
  149.  
  150.   /* Turn off external requests, and stop any DMA in progress */
  151.   dmawp[MCFDMA_DCR] &= ~MCFDMA_DCR_EEXT;
  152.   dmapb[MCFDMA_DSR] = MCFDMA_DSR_DONE;
  153. }
  154.  
  155. /*
  156.  * Clear the 'DMA Pointer Flip Flop'.
  157.  * Write 0 for LSB/MSB, 1 for MSB/LSB access.
  158.  * Use this once to initialize the FF to a known state.
  159.  * After that, keep track of it. :-)
  160.  * --- In order to do that, the DMA routines below should ---
  161.  * --- only be used while interrupts are disabled! ---
  162.  *
  163.  * This is a NOP for ColdFire. Provide a stub for compatibility.
  164.  */
  165. static __inline__ void clear_dma_ff(unsigned int dmanr)
  166. {
  167. }
  168.  
  169. /* set mode (above) for a specific DMA channel */
  170. static __inline__ void set_dma_mode(unsigned int dmanr, char mode)
  171. {
  172.  
  173.   volatile unsigned char  *dmabp;
  174.   volatile unsigned short *dmawp;
  175.  
  176. #ifdef DMA_DEBUG
  177.   printk("set_dma_mode(dmanr=%d,mode=%d)\n", dmanr, mode);
  178. #endif
  179.  
  180.   dmabp = (unsigned char *) dma_base_addr[dmanr];
  181.   dmawp = (unsigned short *) dma_base_addr[dmanr];
  182.  
  183.   // Clear config errors
  184.   dmabp[MCFDMA_DSR] = MCFDMA_DSR_DONE; 
  185.  
  186.   // Set command register
  187.   dmawp[MCFDMA_DCR] =
  188.     MCFDMA_DCR_INT |         // Enable completion irq
  189.     MCFDMA_DCR_CS |          // Force one xfer per request
  190.     MCFDMA_DCR_AA |          // Enable auto alignment
  191.     // single-address-mode
  192.     ((mode & DMA_MODE_SINGLE_BIT) ? MCFDMA_DCR_SAA : 0) |
  193.     // sets s_rw (-> r/w) high if Memory to I/0
  194.     ((mode & DMA_MODE_WRITE_BIT) ? MCFDMA_DCR_S_RW : 0) |
  195.     // Memory to I/O or I/O to Memory
  196.     ((mode & DMA_MODE_WRITE_BIT) ? MCFDMA_DCR_SINC : MCFDMA_DCR_DINC) |
  197.     // 32 bit, 16 bit or 8 bit transfers
  198.     ((mode & DMA_MODE_WORD_BIT)  ? MCFDMA_DCR_SSIZE_WORD : 
  199.      ((mode & DMA_MODE_LONG_BIT) ? MCFDMA_DCR_SSIZE_LONG :
  200.                                    MCFDMA_DCR_SSIZE_BYTE)) |
  201.     ((mode & DMA_MODE_WORD_BIT)  ? MCFDMA_DCR_DSIZE_WORD :
  202.      ((mode & DMA_MODE_LONG_BIT) ? MCFDMA_DCR_DSIZE_LONG :
  203.                                    MCFDMA_DCR_DSIZE_BYTE));
  204.  
  205. #ifdef DEBUG_DMA
  206.   printk("%s(%d): dmanr=%d DSR[%x]=%x DCR[%x]=%x\n", __FILE__, __LINE__,
  207.          dmanr, (int) &dmabp[MCFDMA_DSR], dmabp[MCFDMA_DSR],
  208.      (int) &dmawp[MCFDMA_DCR], dmawp[MCFDMA_DCR]);
  209. #endif
  210. }
  211.  
  212. /* Set transfer address for specific DMA channel */
  213. static __inline__ void set_dma_addr(unsigned int dmanr, unsigned int a)
  214. {
  215.   volatile unsigned short *dmawp;
  216.   volatile unsigned int   *dmalp;
  217.  
  218. #ifdef DMA_DEBUG
  219.   printk("set_dma_addr(dmanr=%d,a=%x)\n", dmanr, a);
  220. #endif
  221.  
  222.   dmawp = (unsigned short *) dma_base_addr[dmanr];
  223.   dmalp = (unsigned int *) dma_base_addr[dmanr];
  224.  
  225.   // Determine which address registers are used for memory/device accesses
  226.   if (dmawp[MCFDMA_DCR] & MCFDMA_DCR_SINC) {
  227.     // Source incrementing, must be memory
  228.     dmalp[MCFDMA_SAR] = a;
  229.     // Set dest address, must be device
  230.     dmalp[MCFDMA_DAR] = dma_device_address[dmanr];
  231.   } else {
  232.     // Destination incrementing, must be memory
  233.     dmalp[MCFDMA_DAR] = a;
  234.     // Set source address, must be device
  235.     dmalp[MCFDMA_SAR] = dma_device_address[dmanr];
  236.   }
  237.  
  238. #ifdef DEBUG_DMA
  239.   printk("%s(%d): dmanr=%d DCR[%x]=%x SAR[%x]=%08x DAR[%x]=%08x\n",
  240.     __FILE__, __LINE__, dmanr, (int) &dmawp[MCFDMA_DCR], dmawp[MCFDMA_DCR],
  241.     (int) &dmalp[MCFDMA_SAR], dmalp[MCFDMA_SAR],
  242.     (int) &dmalp[MCFDMA_DAR], dmalp[MCFDMA_DAR]);
  243. #endif
  244. }
  245.  
  246. /*
  247.  * Specific for Coldfire - sets device address.
  248.  * Should be called after the mode set call, and before set DMA address.
  249.  */
  250. static __inline__ void set_dma_device_addr(unsigned int dmanr, unsigned int a)
  251. {
  252. #ifdef DMA_DEBUG
  253.   printk("set_dma_device_addr(dmanr=%d,a=%x)\n", dmanr, a);
  254. #endif
  255.  
  256.   dma_device_address[dmanr] = a;
  257. }
  258.  
  259. /*
  260.  * NOTE 2: "count" represents _bytes_.
  261.  */
  262. static __inline__ void set_dma_count(unsigned int dmanr, unsigned int count)
  263. {
  264.   volatile unsigned short *dmawp;
  265.  
  266. #ifdef DMA_DEBUG
  267.   printk("set_dma_count(dmanr=%d,count=%d)\n", dmanr, count);
  268. #endif
  269.  
  270.   dmawp = (unsigned short *) dma_base_addr[dmanr];
  271.   dmawp[MCFDMA_BCR] = (unsigned short)count;
  272. }
  273.  
  274. /*
  275.  * Get DMA residue count. After a DMA transfer, this
  276.  * should return zero. Reading this while a DMA transfer is
  277.  * still in progress will return unpredictable results.
  278.  * Otherwise, it returns the number of _bytes_ left to transfer.
  279.  */
  280. static __inline__ int get_dma_residue(unsigned int dmanr)
  281. {
  282.   volatile unsigned short *dmawp;
  283.   unsigned short count;
  284.  
  285. #ifdef DMA_DEBUG
  286.   printk("get_dma_residue(dmanr=%d)\n", dmanr);
  287. #endif
  288.  
  289.   dmawp = (unsigned short *) dma_base_addr[dmanr];
  290.   count = dmawp[MCFDMA_BCR];
  291.   return((int) count);
  292. }
  293. #else /* CONFIG_M5272 is defined */
  294.  
  295. /*
  296.  * The MCF5272 DMA controller is very different than the controller defined above
  297.  * in terms of register mapping.  For instance, with the exception of the 16-bit 
  298.  * interrupt register (IRQ#85, for reference), all of the registers are 32-bit.
  299.  *
  300.  * The big difference, however, is the lack of device-requested DMA.  All modes
  301.  * are dual address transfer, and there is no 'device' setup or direction bit.
  302.  * You can DMA between a device and memory, between memory and memory, or even between
  303.  * two devices directly, with any combination of incrementing and non-incrementing
  304.  * addresses you choose.  This puts a crimp in distinguishing between the 'device 
  305.  * address' set up by set_dma_device_addr.
  306.  *
  307.  * Therefore, there are two options.  One is to use set_dma_addr and set_dma_device_addr,
  308.  * which will act exactly as above in -- it will look to see if the source is set to
  309.  * autoincrement, and if so it will make the source use the set_dma_addr value and the
  310.  * destination the set_dma_device_addr value.  Otherwise the source will be set to the
  311.  * set_dma_device_addr value and the destination will get the set_dma_addr value.
  312.  *
  313.  * The other is to use the provided set_dma_src_addr and set_dma_dest_addr functions
  314.  * and make it explicit.  Depending on what you're doing, one of these two should work
  315.  * for you, but don't mix them in the same transfer setup.
  316.  */
  317.  
  318. /* enable/disable a specific DMA channel */
  319. static __inline__ void enable_dma(unsigned int dmanr)
  320. {
  321.   volatile unsigned int  *dmalp;
  322.  
  323. #ifdef DMA_DEBUG
  324.   printk("enable_dma(dmanr=%d)\n", dmanr);
  325. #endif
  326.  
  327.   dmalp = (unsigned int *) dma_base_addr[dmanr];
  328.   dmalp[MCFDMA_DMR] |= MCFDMA_DMR_EN;
  329. }
  330.  
  331. static __inline__ void disable_dma(unsigned int dmanr)
  332. {
  333.   volatile unsigned int   *dmalp;
  334.  
  335. #ifdef DMA_DEBUG
  336.   printk("disable_dma(dmanr=%d)\n", dmanr);
  337. #endif
  338.  
  339.   dmalp = (unsigned int *) dma_base_addr[dmanr];
  340.  
  341.   /* Turn off external requests, and stop any DMA in progress */
  342.   dmalp[MCFDMA_DMR] &= ~MCFDMA_DMR_EN;
  343.   dmalp[MCFDMA_DMR] |= MCFDMA_DMR_RESET;
  344. }
  345.  
  346. /*
  347.  * Clear the 'DMA Pointer Flip Flop'.
  348.  * Write 0 for LSB/MSB, 1 for MSB/LSB access.
  349.  * Use this once to initialize the FF to a known state.
  350.  * After that, keep track of it. :-)
  351.  * --- In order to do that, the DMA routines below should ---
  352.  * --- only be used while interrupts are disabled! ---
  353.  *
  354.  * This is a NOP for ColdFire. Provide a stub for compatibility.
  355.  */
  356. static __inline__ void clear_dma_ff(unsigned int dmanr)
  357. {
  358. }
  359.  
  360. /* set mode (above) for a specific DMA channel */
  361. static __inline__ void set_dma_mode(unsigned int dmanr, char mode)
  362. {
  363.  
  364.   volatile unsigned int   *dmalp;
  365.   volatile unsigned short *dmawp;
  366.  
  367. #ifdef DMA_DEBUG
  368.   printk("set_dma_mode(dmanr=%d,mode=%d)\n", dmanr, mode);
  369. #endif
  370.   dmalp = (unsigned int *) dma_base_addr[dmanr];
  371.   dmawp = (unsigned short *) dma_base_addr[dmanr];
  372.  
  373.   // Clear config errors
  374.   dmalp[MCFDMA_DMR] |= MCFDMA_DMR_RESET; 
  375.  
  376.   // Set command register
  377.   dmalp[MCFDMA_DMR] =
  378.     MCFDMA_DMR_RQM_DUAL |         // Mandatory Request Mode setting
  379.     MCFDMA_DMR_DSTT_SD  |         // Set up addressing types; set to supervisor-data.
  380.     MCFDMA_DMR_SRCT_SD  |         // Set up addressing types; set to supervisor-data. 
  381.     // source static-address-mode
  382.     ((mode & DMA_MODE_SRC_SA_BIT) ? MCFDMA_DMR_SRCM_SA : MCFDMA_DMR_SRCM_IA) |
  383.     // dest static-address-mode
  384.     ((mode & DMA_MODE_DES_SA_BIT) ? MCFDMA_DMR_DSTM_SA : MCFDMA_DMR_DSTM_IA) |
  385.     // burst, 32 bit, 16 bit or 8 bit transfers are separately configurable on the MCF5272
  386.     (((mode & DMA_MODE_SSIZE_MASK) >> DMA_MODE_SSIZE_OFF) << MCFDMA_DMR_DSTS_OFF) |
  387.     (((mode & DMA_MODE_SSIZE_MASK) >> DMA_MODE_SSIZE_OFF) << MCFDMA_DMR_SRCS_OFF);
  388.     
  389.   dmawp[MCFDMA_DIR] |= MCFDMA_DIR_ASCEN;   /* Enable completion interrupts */
  390.   
  391. #ifdef DEBUG_DMA
  392.   printk("%s(%d): dmanr=%d DMR[%x]=%x DIR[%x]=%x\n", __FILE__, __LINE__,
  393.          dmanr, (int) &dmalp[MCFDMA_DMR], dmabp[MCFDMA_DMR],
  394.      (int) &dmawp[MCFDMA_DIR], dmawp[MCFDMA_DIR]);
  395. #endif
  396. }
  397.  
  398. /* Set transfer address for specific DMA channel */
  399. static __inline__ void set_dma_addr(unsigned int dmanr, unsigned int a)
  400. {
  401.   volatile unsigned int   *dmalp;
  402.  
  403. #ifdef DMA_DEBUG
  404.   printk("set_dma_addr(dmanr=%d,a=%x)\n", dmanr, a);
  405. #endif
  406.  
  407.   dmalp = (unsigned int *) dma_base_addr[dmanr];
  408.  
  409.   // Determine which address registers are used for memory/device accesses
  410.   if (dmalp[MCFDMA_DMR] & MCFDMA_DMR_SRCM) {
  411.     // Source incrementing, must be memory
  412.     dmalp[MCFDMA_DSAR] = a;
  413.     // Set dest address, must be device
  414.     dmalp[MCFDMA_DDAR] = dma_device_address[dmanr];
  415.   } else {
  416.     // Destination incrementing, must be memory
  417.     dmalp[MCFDMA_DDAR] = a;
  418.     // Set source address, must be device
  419.     dmalp[MCFDMA_DSAR] = dma_device_address[dmanr];
  420.   }
  421.  
  422. #ifdef DEBUG_DMA
  423.   printk("%s(%d): dmanr=%d DMR[%x]=%x SAR[%x]=%08x DAR[%x]=%08x\n",
  424.     __FILE__, __LINE__, dmanr, (int) &dmawp[MCFDMA_DMR], dmawp[MCFDMA_DMR],
  425.     (int) &dmalp[MCFDMA_DSAR], dmalp[MCFDMA_DSAR],
  426.     (int) &dmalp[MCFDMA_DDAR], dmalp[MCFDMA_DDAR]);
  427. #endif
  428. }
  429.  
  430. /*
  431.  * Specific for Coldfire - sets device address.
  432.  * Should be called after the mode set call, and before set DMA address.
  433.  */
  434. static __inline__ void set_dma_device_addr(unsigned int dmanr, unsigned int a)
  435. {
  436. #ifdef DMA_DEBUG
  437.   printk("set_dma_device_addr(dmanr=%d,a=%x)\n", dmanr, a);
  438. #endif
  439.  
  440.   dma_device_address[dmanr] = a;
  441. }
  442.  
  443. /*
  444.  * NOTE 2: "count" represents _bytes_.
  445.  *
  446.  * NOTE 3: While a 32-bit register, "count" is only a maximum 24-bit value.
  447.  */
  448. static __inline__ void set_dma_count(unsigned int dmanr, unsigned int count)
  449. {
  450.   volatile unsigned int *dmalp;
  451.   
  452. #ifdef DMA_DEBUG
  453.   printk("set_dma_count(dmanr=%d,count=%d)\n", dmanr, count);
  454. #endif
  455.  
  456.   dmalp = (unsigned int *) dma_base_addr[dmanr];
  457.   dmalp[MCFDMA_DBCR] = count;
  458. }
  459.  
  460. /*
  461.  * Get DMA residue count. After a DMA transfer, this
  462.  * should return zero. Reading this while a DMA transfer is
  463.  * still in progress will return unpredictable results.
  464.  * Otherwise, it returns the number of _bytes_ left to transfer.
  465.  */
  466. static __inline__ int get_dma_residue(unsigned int dmanr)
  467. {
  468.   volatile unsigned int *dmalp;
  469.   unsigned int count;
  470.  
  471. #ifdef DMA_DEBUG
  472.   printk("get_dma_residue(dmanr=%d)\n", dmanr);
  473. #endif
  474.  
  475.   dmalp = (unsigned int *) dma_base_addr[dmanr];
  476.   count = dmalp[MCFDMA_DBCR];
  477.   return(count);
  478. }
  479.  
  480. #endif /* !defined(CONFIG_M5272) */
  481. #endif /* CONFIG_COLDFIRE */
  482.  
  483. #define MAX_DMA_CHANNELS 8
  484.  
  485. /* Don't define MAX_DMA_ADDRESS; it's useless on the m68k/coldfire and any
  486.    occurrence should be flagged as an error.  */
  487. /* under 2.4 it is actually needed by the new bootmem allocator */
  488. #define MAX_DMA_ADDRESS PAGE_OFFSET
  489.  
  490. /* These are in kernel/dma.c: */
  491. extern int request_dma(unsigned int dmanr, const char *device_id);    /* reserve a DMA channel */
  492. extern void free_dma(unsigned int dmanr);    /* release it again */
  493.  
  494. #endif /* _M68K_DMA_H */
  495.